{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "bfeb29c19452c8f782e787e746422cae",
     "grade": false,
     "grade_id": "cell-6e2d08d53786c408",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "# Assignment 3: Function Approximation and Control"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "bc8f8a3eff0506f5f2adbb15d865a6f8",
     "grade": false,
     "grade_id": "cell-c0aa3738f85c68a6",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Welcome to Assignment 3. In this notebook you will learn how to:\n",
    "- Use function approximation in the control setting\n",
    "- Implement the Sarsa algorithm using tile coding\n",
    "- Compare three settings for tile coding to see their effect on our agent\n",
    "\n",
    "As with the rest of the notebooks do not import additional libraries or adjust grading cells as this will break the grader.\n",
    "\n",
    "MAKE SURE TO RUN ALL OF THE CELLS SO THE GRADER GETS THE OUTPUT IT NEEDS\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "9d89a1172d798eea73c3f94e84b19a80",
     "grade": false,
     "grade_id": "cell-3e99c32936b1780b",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "# Import Necessary Libraries\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import tiles3 as tc\n",
    "from rl_glue import RLGlue\n",
    "from agent import BaseAgent\n",
    "from utils import argmax\n",
    "import mountaincar_env\n",
    "import time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "b4b89842d59f53a0397404188fea8a68",
     "grade": false,
     "grade_id": "cell-0c184d76dab0d615",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "In the above cell, we import the libraries we need for this assignment. You may have noticed that we import mountaincar_env. This is the __Mountain Car Task__ introduced in [Section 10.1 of the textbook](http://www.incompleteideas.net/book/RLbook2018.pdf#page=267). The task is for an under powered car to make it to the top of a hill:\n",
    "![Mountain Car](mountaincar.png \"Mountain Car\")\n",
    "The car is under-powered so the agent needs to learn to rock back and forth to get enough momentum to reach the goal. At each time step the agent receives from the environment its current velocity (a float between -0.07 and 0.07), and it's current position (a float between -1.2 and 0.5). Because our state is continuous there are a potentially infinite number of states that our agent could be in. We need a function approximation method to help the agent deal with this. In this notebook we will use tile coding. We provide a tile coding implementation for you to use, imported above with tiles3."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "ec2c6de4858e1844bbba0fb965fb1697",
     "grade": false,
     "grade_id": "cell-abeb1cf4c7319766",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## Section 0: Tile Coding Helper Function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "9948acdae6f3a64b7c81cf049ebb80a2",
     "grade": false,
     "grade_id": "cell-6b462acd2d7d2b79",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "To begin we are going to build a tile coding class for our Sarsa agent that will make it easier to make calls to our tile coder."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "3ead2ccf72a2be17e6781d5b76e84219",
     "grade": false,
     "grade_id": "cell-85d6085e6342eb1c",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "### Tile Coding Function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "50b0abf997f87549fd27944b04e5b57c",
     "grade": false,
     "grade_id": "cell-2067725dbeb55d8b",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Tile coding is introduced in [Section 9.5.4 of the textbook](http://www.incompleteideas.net/book/RLbook2018.pdf#page=239) of the textbook as a way to create features that can both provide good generalization and discrimination. It consists of multiple overlapping tilings, where each tiling is a partitioning of the space into tiles.\n",
    "![Tile Coding](tilecoding.png \"Tile Coding\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "810ec33572588560507256351c37be9d",
     "grade": false,
     "grade_id": "cell-7fc517d0f2a4618e",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "To help keep our agent code clean we are going to make a function specific for tile coding for our Mountain Car environment. To help we are going to use the Tiles3 library. This is a Python 3 implementation of the tile coder. To start take a look at the documentation: [Tiles3 documentation](http://incompleteideas.net/tiles/tiles3.html)\n",
    "To get the tile coder working we need to implement a few pieces:\n",
    "- First: create an index hash table - this is done for you in the init function using tc.IHT.\n",
    "- Second is to scale the inputs for the tile coder based on the number of tiles and the range of values each input could take. The tile coder needs to take in a number in range [0, 1], or scaled to be [0, 1] * num_tiles. For more on this refer to the [Tiles3 documentation](http://incompleteideas.net/tiles/tiles3.html).\n",
    "- Finally we call tc.tiles to get the active tiles back."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "960c0a3aaa33badde927b45c7a4ebb96",
     "grade": false,
     "grade_id": "cell-12821f87b5c813b2",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# Tile Coding Function [Graded]\n",
    "class MountainCarTileCoder:\n",
    "    def __init__(self, iht_size=4096, num_tilings=8, num_tiles=8):\n",
    "        \"\"\"\n",
    "        Initializes the MountainCar Tile Coder\n",
    "        Initializers:\n",
    "        iht_size -- int, the size of the index hash table, typically a power of 2\n",
    "        num_tilings -- int, the number of tilings\n",
    "        num_tiles -- int, the number of tiles. Here both the width and height of the\n",
    "                     tile coder are the same\n",
    "        Class Variables:\n",
    "        self.iht -- tc.IHT, the index hash table that the tile coder will use\n",
    "        self.num_tilings -- int, the number of tilings the tile coder will use\n",
    "        self.num_tiles -- int, the number of tiles the tile coder will use\n",
    "        \"\"\"\n",
    "        self.iht = tc.IHT(iht_size)\n",
    "        self.num_tilings = num_tilings\n",
    "        self.num_tiles = num_tiles\n",
    "    \n",
    "    def get_tiles(self, position, velocity):\n",
    "        \"\"\"\n",
    "        Takes in a position and velocity from the mountaincar environment\n",
    "        and returns a numpy array of active tiles.\n",
    "        \n",
    "        Arguments:\n",
    "        position -- float, the position of the agent between -1.2 and 0.5\n",
    "        velocity -- float, the velocity of the agent between -0.07 and 0.07\n",
    "        returns:\n",
    "        tiles - np.array, active tiles\n",
    "        \"\"\"\n",
    "        # Set the max and min of position and velocity to scale the input\n",
    "        # POSITION_MIN\n",
    "        # POSITION_MAX\n",
    "        # VELOCITY_MIN\n",
    "        # VELOCITY_MAX\n",
    "        ### START CODE HERE ###\n",
    "        POSITION_MIN = -1.2\n",
    "        POSITION_MAX = 0.5\n",
    "        \n",
    "        VELOCITY_MIN = -0.07\n",
    "        VELOCITY_MAX = 0.07\n",
    "        \n",
    "        ### END CODE HERE ###\n",
    "        \n",
    "        # Use the ranges above and self.num_tiles to set position_scale and velocity_scale\n",
    "        # position_scale = number of tiles / position range\n",
    "        # velocity_scale = number of tiles / velocity range\n",
    "        \n",
    "        # Scale position and velocity by multiplying the inputs of each by their scale\n",
    "        \n",
    "        ### START CODE HERE ###\n",
    "        position_scale = self.num_tiles/(POSITION_MAX - POSITION_MIN)\n",
    "        velocity_scale = self.num_tiles/(VELOCITY_MAX - VELOCITY_MIN)\n",
    "        \n",
    "        ### END CODE HERE ###\n",
    "        \n",
    "        # get the tiles using tc.tiles, with self.iht, self.num_tilings and [scaled position, scaled velocity]\n",
    "        # nothing to implment here\n",
    "        tiles = tc.tiles(self.iht, self.num_tilings, [position * position_scale, \n",
    "                                                      velocity * velocity_scale])\n",
    "        \n",
    "        return np.array(tiles)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "2f9114c9e8fe820a8d131b87e4c589a6",
     "grade": false,
     "grade_id": "cell-2c8b58b5dc63cc52",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your results:\n",
      "[0 1 2 3 4 5 6 7]\n",
      "[ 8  9 10 11 12 13 14 15]\n",
      "[16 17 18 19 20 21 22 23]\n",
      "[ 0 24  2  3  4  5  6  7]\n",
      "[16 17 18 19 20 21 22 23]\n",
      "\n",
      "Expected results:\n",
      "[0 1 2 3 4 5 6 7]\n",
      "[ 8  9 10 11 12 13 14 15]\n",
      "[16 17 18 19 20 21 22 23]\n",
      "[ 0 24  2  3  4  5  6  7]\n",
      "[16 17 18 19 20 21 22 23]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# [DO NOT CHANGE]\n",
    "tests = [[-1.0, 0.01], [0.1, -0.01], [0.2, -0.05], [-1.0, 0.011], [0.2, -0.05]]\n",
    "\n",
    "mctc = MountainCarTileCoder(iht_size=1024, num_tilings=8, num_tiles=8)\n",
    "\n",
    "t = []\n",
    "for test in tests:\n",
    "    position, velocity = test\n",
    "    tiles = mctc.get_tiles(position=position, velocity=velocity)\n",
    "    t.append(tiles)\n",
    "\n",
    "print(\"Your results:\")\n",
    "for tiles in t:\n",
    "    print(tiles)\n",
    "\n",
    "print()\n",
    "print(\"Expected results:\")\n",
    "expected = \"\"\"[0 1 2 3 4 5 6 7]\n",
    "[ 8  9 10 11 12 13 14 15]\n",
    "[16 17 18 19 20 21 22 23]\n",
    "[ 0 24  2  3  4  5  6  7]\n",
    "[16 17 18 19 20 21 22 23]\n",
    "\"\"\"\n",
    "print(expected)\n",
    "\n",
    "np.random.seed(1)\n",
    "mctc_test = MountainCarTileCoder(iht_size=1024, num_tilings=8, num_tiles=8)\n",
    "test = [mctc_test.get_tiles(np.random.uniform(-1.2, 0.5), np.random.uniform(-0.07, 0.07)) for _ in range(10)]\n",
    "np.save(\"tiles_test\", test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "fdaa393fe01b7bebe2ff44aeabc1a233",
     "grade": false,
     "grade_id": "cell-b647e597fb7ee2e4",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## Section 1: Sarsa Agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "d8b0c1c1cab5bd89cc9479e3faad7539",
     "grade": false,
     "grade_id": "cell-bc36b07292c6751a",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "We are now going to use the functions that we just created to implement the Sarsa algorithm. Recall from class that Sarsa stands for State, Action, Reward, State, Action.\n",
    "\n",
    "For this case we have given you an argmax function similar to what you wrote back in Course 1 Assignment 1. Recall, this is different than the argmax function that is used by numpy, which returns the first index of a maximum value. We want our argmax function to arbitrarily break ties, which is what the imported argmax function does. The given argmax function takes in an array of values and returns an int of the chosen action: \n",
    "argmax(action values)\n",
    "\n",
    "There are multiple ways that we can deal with actions for the tile coder. Here we are going to use one simple method - make the size of the weight vector equal to (iht_size, num_actions). This will give us one weight vector for each action and one weight for each tile.\n",
    "\n",
    "Use the above function to help fill in select_action, agent_start, agent_step, and agent_end.\n",
    "\n",
    "Hints:\n",
    "\n",
    "1) The tile coder returns a list of active indexes (e.g. [1, 12, 22]). You can index a numpy array using an array of values - this will return an array of the values at each of those indices. So in order to get the value of a state we can index our weight vector using the action and the array of tiles that the tile coder returns:\n",
    "\n",
    "```self.w[action][active_tiles]```\n",
    "\n",
    "This will give us an array of values, one for each active tile, and we sum the result to get the value of that state-action pair.\n",
    "\n",
    "2) In the case of a binary feature vector (such as the tile coder), the derivative is 1 at each of the active tiles, and zero otherwise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "deletable": false,
    "nbgrader": {
     "checksum": "c899864c5d5422ec74315ab7ec2ae092",
     "grade": false,
     "grade_id": "cell-f01df3aacf5a9d4b",
     "locked": false,
     "schema_version": 1,
     "solution": true
    }
   },
   "outputs": [],
   "source": [
    "# SARSA\n",
    "class SarsaAgent(BaseAgent):\n",
    "    \"\"\"\n",
    "    Initialization of Sarsa Agent. All values are set to None so they can\n",
    "    be initialized in the agent_init method.\n",
    "    \"\"\"\n",
    "    def __init__(self):\n",
    "        self.last_action = None\n",
    "        self.last_state = None\n",
    "        self.epsilon = None\n",
    "        self.gamma = None\n",
    "        self.iht_size = None\n",
    "        self.w = None\n",
    "        self.alpha = None\n",
    "        self.num_tilings = None\n",
    "        self.num_tiles = None\n",
    "        self.mctc = None\n",
    "        self.initial_weights = None\n",
    "        self.num_actions = None\n",
    "        self.previous_tiles = None\n",
    "\n",
    "    def agent_init(self, agent_info={}):\n",
    "        \"\"\"Setup for the agent called when the experiment first starts.\"\"\"\n",
    "        self.num_tilings = agent_info.get(\"num_tilings\", 8)\n",
    "        self.num_tiles = agent_info.get(\"num_tiles\", 8)\n",
    "        self.iht_size = agent_info.get(\"iht_size\", 4096)\n",
    "        self.epsilon = agent_info.get(\"epsilon\", 0.0)\n",
    "        self.gamma = agent_info.get(\"gamma\", 1.0)\n",
    "        self.alpha = agent_info.get(\"alpha\", 0.5) / self.num_tilings\n",
    "        self.initial_weights = agent_info.get(\"initial_weights\", 0.0)\n",
    "        self.num_actions = agent_info.get(\"num_actions\", 3)\n",
    "        \n",
    "        # We initialize self.w to three times the iht_size. Recall this is because\n",
    "        # we need to have one set of weights for each action.\n",
    "        self.w = np.ones((self.num_actions, self.iht_size)) * self.initial_weights\n",
    "        \n",
    "        # We initialize self.mctc to the mountaincar verions of the \n",
    "        # tile coder that we created\n",
    "        self.tc = MountainCarTileCoder(iht_size=self.iht_size, \n",
    "                                         num_tilings=self.num_tilings, \n",
    "                                         num_tiles=self.num_tiles)\n",
    "\n",
    "    def select_action(self, tiles):\n",
    "        \"\"\"\n",
    "        Selects an action using epsilon greedy\n",
    "        Args:\n",
    "        tiles - np.array, an array of active tiles\n",
    "        Returns:\n",
    "        (chosen_action, action_value) - (int, float), tuple of the chosen action\n",
    "                                        and it's value\n",
    "        \"\"\"\n",
    "        action_values = []\n",
    "        chosen_action = None\n",
    "        \n",
    "        # First loop through the weights of each action and populate action_values\n",
    "        # with the action value for each action and tiles instance\n",
    "        \n",
    "        # Use np.random.random to decide if an exploritory action should be taken\n",
    "        # and set chosen_action to a random action if it is\n",
    "        # Otherwise choose the greedy action using the given argmax \n",
    "        # function and the action values (don't use numpy's armax)\n",
    "        \n",
    "        ### START CODE HERE ###\n",
    "        \n",
    "        for action in range(len(self.w)):\n",
    "            \n",
    "            action_values.append(np.sum(self.w[action][tiles]))\n",
    "        \n",
    "        if np.random.random() <= self.epsilon:\n",
    "            chosen_action = np.random.choice(self.num_actions)\n",
    "            \n",
    "        else:\n",
    "            chosen_action = argmax(action_values)\n",
    "        ### END CODE HERE ###\n",
    "        \n",
    "        return chosen_action, action_values[chosen_action]\n",
    "    \n",
    "    def agent_start(self, state):\n",
    "        \"\"\"The first method called when the experiment starts, called after\n",
    "        the environment starts.\n",
    "        Args:\n",
    "            state (Numpy array): the state observation from the\n",
    "                environment's evn_start function.\n",
    "        Returns:\n",
    "            The first action the agent takes.\n",
    "        \"\"\"\n",
    "        position, velocity = state\n",
    "        \n",
    "        # Use self.tc to set active_tiles using position and velocity\n",
    "        # set current_action to the epsilon greedy chosen action using\n",
    "        # the select_action function above with the active tiles\n",
    "        \n",
    "        ### START CODE HERE ###\n",
    "        active_tiles = self.tc.get_tiles(position = position, velocity = velocity)\n",
    "        current_action, action_value = self.select_action(active_tiles)\n",
    "        ### END CODE HERE ###\n",
    "        \n",
    "        self.last_action = current_action\n",
    "        self.previous_tiles = np.copy(active_tiles)\n",
    "        return self.last_action\n",
    "\n",
    "    def agent_step(self, reward, state):\n",
    "        \"\"\"A step taken by the agent.\n",
    "        Args:\n",
    "            reward (float): the reward received for taking the last action taken\n",
    "            state (Numpy array): the state observation from the\n",
    "                environment's step based, where the agent ended up after the\n",
    "                last step\n",
    "        Returns:\n",
    "            The action the agent is taking.\n",
    "        \"\"\"\n",
    "        # choose the action here\n",
    "        position, velocity = state\n",
    "        \n",
    "        # Use self.tc to set active_tiles using position and velocity\n",
    "        # set current_action and action_value to the epsilon greedy chosen action using\n",
    "        # the select_action function above with the active tiles\n",
    "        \n",
    "        # Update self.w at self.previous_tiles and self.previous action\n",
    "        # using the reward, action_value, self.gamma, self.w,\n",
    "        # self.alpha, and the Sarsa update from the textbook\n",
    "        \n",
    "        ### START CODE HERE ###\n",
    "        active_tiles = self.tc.get_tiles(position = position, velocity = velocity)\n",
    "        current_action, action_value = self.select_action(active_tiles)\n",
    "        \n",
    "        last_action_value = np.sum(self.w[self.last_action][self.previous_tiles])\n",
    "        delta = reward + self.gamma*action_value - last_action_value\n",
    "#         print(self.w[self.last_action][self.previous_tiles].shape)\n",
    "        grad = np.ones(self.w[self.last_action][self.previous_tiles].shape)\n",
    "        \n",
    "        self.w[self.last_action][self.previous_tiles] = self.w[self.last_action][self.previous_tiles] + self.alpha*delta*grad\n",
    "        \n",
    "        ### END CODE HERE ###\n",
    "        \n",
    "        self.last_action = current_action\n",
    "        self.previous_tiles = np.copy(active_tiles)\n",
    "        return self.last_action\n",
    "\n",
    "    def agent_end(self, reward):\n",
    "        \"\"\"Run when the agent terminates.\n",
    "        Args:\n",
    "            reward (float): the reward the agent received for entering the\n",
    "                terminal state.\n",
    "        \"\"\"\n",
    "        # Update self.w at self.previous_tiles and self.previous action\n",
    "        # using the reward, self.gamma, self.w,\n",
    "        # self.alpha, and the Sarsa update from the textbook\n",
    "        # Hint - there is no action_value used here because this is the end\n",
    "        # of the episode.\n",
    "        \n",
    "        ### START CODE HERE ###\n",
    "\n",
    "        \n",
    "        last_action_value = np.sum(self.w[self.last_action][self.previous_tiles])\n",
    "        delta = reward\n",
    "        \n",
    "        grad = np.ones(self.w[self.last_action][self.previous_tiles].shape)\n",
    "\n",
    "       \n",
    "        self.w[self.last_action][self.previous_tiles] = self.w[self.last_action][self.previous_tiles] + self.alpha*delta*grad\n",
    "        \n",
    "        \n",
    "        ### END CODE HERE ###\n",
    "        \n",
    "    def agent_cleanup(self):\n",
    "        \"\"\"Cleanup done after the agent ends.\"\"\"\n",
    "        pass\n",
    "\n",
    "    def agent_message(self, message):\n",
    "        \"\"\"A function used to pass information from the agent to the experiment.\n",
    "        Args:\n",
    "            message: The message passed to the agent.\n",
    "        Returns:\n",
    "            The response (or answer) to the message.\n",
    "        \"\"\"\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "cd2e581d58b48f8be57ecd190b2b6e6a",
     "grade": false,
     "grade_id": "cell-4363d332fa1b0f96",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14460\n",
      "Expected value\n",
      "(2, 15)\n",
      "Your value\n",
      "(2, 15)\n"
     ]
    }
   ],
   "source": [
    "# Test Epsilon Greedy Function [DO NOT CHANGE]\n",
    "agent = SarsaAgent()\n",
    "agent.agent_init({\"epsilon\": 0.1})\n",
    "agent.w = np.array([np.array([1, 2, 3]), np.array([4, 5, 6]), np.array([7, 8, 9])])\n",
    "\n",
    "total = 0\n",
    "for i in range(1000):\n",
    "    chosen_action, action_value = agent.select_action(np.array([0,1]))\n",
    "    total += action_value\n",
    "print(total)\n",
    "assert total < 15000, \"Check that you are not always choosing the best action\"\n",
    "\n",
    "np.save(\"epsilon_test\", total)\n",
    "\n",
    "agent = SarsaAgent()\n",
    "agent.agent_init({\"epsilon\": 0.0})\n",
    "agent.w = np.array([np.array([1, 2, 3]), np.array([4, 5, 6]), np.array([7, 8, 9])])\n",
    "\n",
    "chosen_action, action_value = agent.select_action(np.array([0,1]))\n",
    "print(\"Expected value\")\n",
    "print(\"(2, 15)\")\n",
    "\n",
    "print(\"Your value\")\n",
    "print((chosen_action, action_value))\n",
    "\n",
    "np.save(\"egreedy_test\", (chosen_action, action_value))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "8082fe078300cb738d2dd10f590a3535",
     "grade": false,
     "grade_id": "cell-aa40398d933320db",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RUN: 0\n",
      "RUN: 5\n",
      "Run time: 10.552968740463257\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Test Sarsa Agent [DO NOT CHANGE]\n",
    "num_runs = 10\n",
    "num_episodes = 50\n",
    "env_info = {\"num_tiles\": 8, \"num_tilings\": 8}\n",
    "agent_info = {}\n",
    "all_steps = []\n",
    "\n",
    "agent = SarsaAgent\n",
    "env = mountaincar_env.Environment\n",
    "start = time.time()\n",
    "\n",
    "for run in range(num_runs):\n",
    "    if run % 5 == 0:\n",
    "        print(\"RUN: {}\".format(run))\n",
    "\n",
    "    rl_glue = RLGlue(env, agent)\n",
    "    rl_glue.rl_init(agent_info, env_info)\n",
    "    steps_per_episode = []\n",
    "\n",
    "    for episode in range(num_episodes):\n",
    "        rl_glue.rl_episode(15000)\n",
    "        steps_per_episode.append(rl_glue.num_steps)\n",
    "\n",
    "    all_steps.append(np.array(steps_per_episode))\n",
    "\n",
    "print(\"Run time: {}\".format(time.time() - start))\n",
    "\n",
    "plt.plot(np.mean(np.array(all_steps), axis=0))\n",
    "np.save(\"sarsa_test\", np.array(all_steps))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "76a454920dcb6dd3d10d811a2f4dfa21",
     "grade": false,
     "grade_id": "cell-25c387a04d2d325f",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "The learning rate of your agent should look similar to ours, though it will not look exactly the same.If there are some spikey points that is okay. Due to stochasticity,  a few episodes may have taken much longer, causing some spikes in the plot. The trend of the line should be similar, though, generally decreasing to about 200 steps per run.\n",
    "![alt text](sarsa_agent_initial.png \"Logo Title Text 1\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "59a8c32add9b94d547093defbc0958cf",
     "grade": false,
     "grade_id": "cell-b8423d7852d12941",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "This result was using 8 tilings with 8x8 tiles on each. Let's see if we can do better, and what different tilings look like. We will also text 2 tilings of 16x16 and 4 tilings of 32x32. These three choices produce the same number of features (512), but distributed quite differently. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "da19e771d808db89cb738f0c84fcecca",
     "grade": false,
     "grade_id": "cell-779d7aea26f74686",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RUN: 0\n",
      "RUN: 5\n",
      "RUN: 10\n",
      "RUN: 15\n",
      "0.25\n",
      "Run Time: 54.13163661956787\n",
      "RUN: 0\n",
      "RUN: 5\n",
      "RUN: 10\n",
      "RUN: 15\n",
      "0.015625\n",
      "Run Time: 33.53700542449951\n",
      "RUN: 0\n",
      "RUN: 5\n",
      "RUN: 10\n",
      "RUN: 15\n",
      "0.0625\n",
      "Run Time: 33.732555627822876\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fea2c8e8b38>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Compare the three\n",
    "num_runs = 20\n",
    "num_episodes = 100\n",
    "env_info = {}\n",
    "\n",
    "agent_runs = []\n",
    "# alphas = [0.2, 0.4, 0.5, 1.0]\n",
    "alphas = [0.5]\n",
    "agent_info_options = [{\"num_tiles\": 16, \"num_tilings\": 2, \"alpha\": 0.5},\n",
    "                      {\"num_tiles\": 4, \"num_tilings\": 32, \"alpha\": 0.5},\n",
    "                      {\"num_tiles\": 8, \"num_tilings\": 8, \"alpha\": 0.5}]\n",
    "agent_info_options = [{\"num_tiles\" : agent[\"num_tiles\"], \n",
    "                       \"num_tilings\": agent[\"num_tilings\"],\n",
    "                       \"alpha\" : alpha} for agent in agent_info_options for alpha in alphas]\n",
    "\n",
    "agent = SarsaAgent\n",
    "env = mountaincar_env.Environment\n",
    "for agent_info in agent_info_options:\n",
    "    all_steps = []\n",
    "    start = time.time()\n",
    "    for run in range(num_runs):\n",
    "        if run % 5 == 0:\n",
    "            print(\"RUN: {}\".format(run))\n",
    "        env = mountaincar_env.Environment\n",
    "        \n",
    "        rl_glue = RLGlue(env, agent)\n",
    "        rl_glue.rl_init(agent_info, env_info)\n",
    "        steps_per_episode = []\n",
    "\n",
    "        for episode in range(num_episodes):\n",
    "            rl_glue.rl_episode(15000)\n",
    "            steps_per_episode.append(rl_glue.num_steps)\n",
    "        all_steps.append(np.array(steps_per_episode))\n",
    "    \n",
    "    agent_runs.append(np.mean(np.array(all_steps), axis=0))\n",
    "    print(rl_glue.agent.alpha)\n",
    "    print(\"Run Time: {}\".format(time.time() - start))\n",
    "\n",
    "plt.figure(figsize=(15, 10), dpi= 80, facecolor='w', edgecolor='k')\n",
    "plt.plot(np.array(agent_runs).T)\n",
    "plt.xlabel(\"Episode\")\n",
    "plt.ylabel(\"Steps Per Episode\")\n",
    "plt.yscale(\"linear\")\n",
    "plt.ylim(0, 1000)\n",
    "plt.legend([\"num_tiles: {}, num_tilings: {}, alpha: {}\".format(agent_info[\"num_tiles\"], \n",
    "                                                               agent_info[\"num_tilings\"],\n",
    "                                                               agent_info[\"alpha\"])\n",
    "            for agent_info in agent_info_options])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "6038f4c142bec2a4e78e32ddf9c249de",
     "grade": false,
     "grade_id": "cell-b7e2f943ac40b395",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Here we can see that using 32 tilings and 4 x 4 tiles does a little better than 8 tilings with 8x8 tiles. Both seem to do much better than using 2 tilings, with 16 x 16 tiles."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "63a8d309f64550844d8d8669796da9e6",
     "grade": false,
     "grade_id": "cell-279952a048a11f2a",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "## Section 3: Conclusion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": false,
    "editable": false,
    "nbgrader": {
     "checksum": "d2f0a01598313c64677f7ea426cad9cc",
     "grade": false,
     "grade_id": "cell-a2e2660173b7334f",
     "locked": true,
     "schema_version": 1,
     "solution": false
    }
   },
   "source": [
    "Congratulations! You have learned how to implement a control agent using function approximation. In this notebook you learned how to:\n",
    "\n",
    "- Use function approximation in the control setting\n",
    "- Implement the Sarsa algorithm using tile coding\n",
    "- Compare three settings for tile coding to see their effect on our agent"
   ]
  }
 ],
 "metadata": {
  "@webio": {
   "lastCommId": null,
   "lastKernelId": null
  },
  "coursera": {
   "course_slug": "prediction-control-function-approximation",
   "graded_item_id": "N1YGC",
   "launcher_item_id": "UJo5o"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
